﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using System.Collections.ObjectModel;
using System.Data;
using System.IO;
using System.Globalization;
using produccion.reportes;
using produccion.vistamodelo;

namespace produccion.forms
{
    /// <summary>
    /// Lógica de interacción para FRMdevCli.xaml
    /// </summary>
    public partial class FRMdevCli : Window
    {
        public FRMdevCli()
        {
            InitializeComponent();
        }

        private void butGra_Click(object sender, RoutedEventArgs e)
        {
            devCli.Instance.guardar();
        }

        private void butSal_Click(object sender, RoutedEventArgs e)
        {
            this.Close();
        }

        private void butExaLog_Click(object sender, RoutedEventArgs e)
        {
            devCli.Instance.cargarArchivo();
        }

        private void datInf_LostFocus(object sender, RoutedEventArgs e)
        {
            Boolean errors = (from c in
                                  (from object i in datInf.ItemsSource select datInf.ItemContainerGenerator.ContainerFromItem(i))
                              where c != null
                              select Validation.GetHasError(c)).FirstOrDefault(x => x);

            devCli.Instance.ERROR = errors;

        }

        private void Window_Closed(object sender, EventArgs e)
        {
            devCli.Instance = null;
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            Keyboard.Focus(comCli);
        }

        private void datInf_PreviewKeyDown(object sender, KeyEventArgs e)
        {
            var elemento = e.OriginalSource as UIElement;
            if (e.Key == Key.Enter && elemento != null)
            {
                e.Handled = true;
                elemento.MoveFocus(new TraversalRequest(FocusNavigationDirection.Next));
            }
        }

        //
        // SINGLE CLICK EDITING
        //
        private void DataGridCell_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            DataGridCell cell = sender as DataGridCell;
            if (cell != null && !cell.IsEditing && !cell.IsReadOnly)
            {
                if (!cell.IsFocused)
                {
                    cell.Focus();
                }
                DataGrid dataGrid = FindVisualParent<DataGrid>(cell);
                if (dataGrid != null)
                {
                    if (dataGrid.SelectionUnit != DataGridSelectionUnit.FullRow)
                    {
                        if (!cell.IsSelected)
                            cell.IsSelected = true;
                    }
                    else
                    {
                        DataGridRow row = FindVisualParent<DataGridRow>(cell);
                        if (row != null && !row.IsSelected)
                        {
                            row.IsSelected = true;
                        }
                    }
                }
            }
        }

        static T FindVisualParent<T>(UIElement element) where T : UIElement
        {
            UIElement parent = element;
            while (parent != null)
            {
                T correctlyTyped = parent as T;
                if (correctlyTyped != null)
                {
                    return correctlyTyped;
                }

                parent = VisualTreeHelper.GetParent(parent) as UIElement;
            }
            return null;
        }

        private void Window_KeyDown(object sender, KeyEventArgs e)
        {
            var elemento = e.OriginalSource as UIElement;
            if (e.Key == Key.F3 && elemento != null)
            {
                if (MDOgeneral.logBusquedadAbierta == true) { MDOgeneral.logBusquedadAbierta = false; }
            }

            if (e.Key == Key.F4 && elemento != null)
            {
                if (MDOgeneral.logBusquedadAbierta1 == true) { MDOgeneral.logBusquedadAbierta1 = false; }
            }

            if (e.Key == Key.F5 && elemento != null)
            {
                if (MDOgeneral.logBusquedadAbierta2 == true) { MDOgeneral.logBusquedadAbierta2 = false; }
            }
        } 

    }




    public class devCli:ObservableObject {

        #region singleton
        private static devCli instance = null;
        
        protected devCli() {
            consCli();
            consNroDev();

            MDOgeneral.conectar();
            strTituloVentana = "Devoluciones de clientes - Usuario: " + MDOgeneral.usuario + " - [FRMdevCli]";
        }
        
        public static devCli Instance
        {
            get
            {
            if (instance == null)
                instance = new devCli();
               return instance;
             }
           set { 
              if (instance != null)
                instance = null;
             }
        }
        #endregion

        private string _strTituloVentana;
        public string strTituloVentana
        {
            get { return _strTituloVentana; }
            set { _strTituloVentana = value; RaisePropertyChangedEvent("strTituloVentana"); }
        }

        private string _numero;
        public string numero {
            get { return _numero;}
            set { _numero = value;
            RaisePropertyChangedEvent("numero");
            }
        }

        private DateTime _fecha = DateTime.Today;
        public DateTime fecha {
            get { return _fecha;}
            set { _fecha = value;
            RaisePropertyChangedEvent("fecha");
            }
        }
        
        private string _documento="";
        public string documento {
            get { return _documento;}
            set { _documento = value;
            msn.texto = "";
            RaisePropertyChangedEvent("documento");
            }
        }

        private string _observacion;
        public string observacion {
            get { return _observacion; }
            set { _observacion = value;
            RaisePropertyChangedEvent("observacion");
            }
        }

        private ObservableCollection<devolucion> _devoluciones = new ObservableCollection<devolucion>();
        public ObservableCollection<devolucion> devoluciones {
            get { return _devoluciones; }
            set
            {   _devoluciones = value;
                RaisePropertyChangedEvent("devoluciones");
            }
        }

        private devolucion _selDev = new devolucion();
        public devolucion selDev
        {
            get { return _selDev; }
            set {
                _selDev = value;

                if (_selDev != null)
                {

                    if (_selDev.codref.Length >= 6)
                    {
                        visorFotoReferencia.strCodigo = _selDev.codref.Substring(0, 4);
                        visorFotoReferencia.strColor = _selDev.codref.Substring(4, 2);
                    }
                }
                else
                {
                    visorFotoReferencia.strCodigo="";
                }
                RaisePropertyChangedEvent("selDev");
            }

        }

        private VMvisorFotoReferencia _visorFotoReferencia = new VMvisorFotoReferencia();
        public VMvisorFotoReferencia visorFotoReferencia
        {
            get { return _visorFotoReferencia; }
            set { _visorFotoReferencia = value; base.OnPropertyChanged("visorFotoReferencia"); }
        }

        private List<clases.CLSMAECLIP> _lisCli = new List<clases.CLSMAECLIP>();
        public List<clases.CLSMAECLIP> lisCli {
            get { return _lisCli; }
            set { _lisCli = value;
            RaisePropertyChangedEvent("lisCli");
            }
        }

        private clases.CLSMAECLIP _selCli = new clases.CLSMAECLIP();
        public clases.CLSMAECLIP selCli {
            get { return _selCli; }
            set { _selCli = value;
            RaisePropertyChangedEvent("selCli");
            }
        }

        private string _codcli;
        public string codcli {
            get { return _codcli; }
            set { _codcli = value;
            selCli.CODCLI_CLI = codcli;
            RaisePropertyChangedEvent("codcli");
            }
        }

        public void consCli() {
            try {
                lisCli = new clases.CLSMAECLIP().listaCliente();    
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        public void consNroDev() {
            try {
                clases.CLSENCDEVP enc = new clases.CLSENCDEVP();
                numero= enc.QueryNroDev();
            
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        public class devolucion:ObservableObject
        {
            private string _codref="";
            public string codref {
                get{  return _codref;}
                set { _codref = value;
                if (!String.IsNullOrEmpty(_codref)) {
                    if (_codref.Length >= 4)
                    {
                        clases.CLSMAEREF maeref = new clases.CLSMAEREF { CODREF_REF = codref.Substring(0,4) };
                        maeref.Consultar();
                        nomref = maeref.NOMREF_REF;
                    }
                }
                RaisePropertyChangedEvent("codref");
                }
            }

            private string _nomref;
            public string nomref {
                get { return _nomref; }
                set { _nomref = value;
                RaisePropertyChangedEvent("nomref");
                }
            }
            
            private string _codda1;
            public string codda1
            {
                get { return _codda1; }
                set
                {
                    _codda1 = value;
                    RaisePropertyChangedEvent("codda1");
                }
            }

            private string _codda2;
            public string codda2
            {
                get { return _codda2; }
                set
                {
                    _codda2 = value;
                    RaisePropertyChangedEvent("codda2");
                }
            }

            private string _codda3;
            public string codda3
            {
                get { return _codda3; }
                set
                {
                    _codda3 = value;
                    RaisePropertyChangedEvent("codda3");
                }
            }

            private string _codpie;
            public string codpie
            {
                get { return _codpie; }
                set
                {
                    _codpie = value;
                    RaisePropertyChangedEvent("codpie");
                }
            }

            private string _codres;
            public string codres
            {
                get { return _codres; }
                set
                {
                    _codres = value;
                }
            }

            private string _pq;
            public string pq
            {
                get { return _pq; }
                set
                {
                    _pq = value;
                    RaisePropertyChangedEvent("pq");
                }
            }

            private string _qh;
            public string qh
            {
                get { return _qh; }
                set
                {
                    _qh = value;
                    RaisePropertyChangedEvent("qh");
                }
            }

            private string _decide;
            public string decide
            {
                get { return _decide; }
                set { _decide = value; }
            }

            private int _cantidad;
            public int cantidad {
                get { return _cantidad; }
                set { _cantidad = value;
                RaisePropertyChangedEvent("cantidad");
                }
            
            }

            private string _tipo="D";
            public string tipo {
                get { return _tipo; }
                set { _tipo = value;
                RaisePropertyChangedEvent("tipo");
                }
            }
            
        }
        
        private DataTable _lisDan = new clases.CLSTABDAN().listarAllDano();
        public DataTable lisDan {
            get { return _lisDan; }
            set { _lisDan = value;
            RaisePropertyChangedEvent("lisDan");
            }
        }
        
        private DataTable _lisPie = new clases.CLSTABPIE().consLisPie();
        public DataTable lisPie {
            get { return _lisPie; }
            set { _lisPie = value;
            RaisePropertyChangedEvent("lisPie");
            }
        }

        private DataTable _lisEmp = new clases.CLSMAEEMPP().consLisEmp();
        public DataTable lisEmp {
            get { return _lisEmp; }
            set { _lisEmp = value;
            RaisePropertyChangedEvent("lisEmp");
            }
        }
        
        private DataTable _lisPQ = new clases.CLSTABCAU().consLisCau();
        public DataTable lisPQ {
            get { return _lisPQ; }
            set { _lisPQ = value;
            RaisePropertyChangedEvent("lisPQ");
            }        
        }

        private DataTable _lisQH = new clases.CLSTABSOL().consLisSol();
        public DataTable lisQH {
            get { return _lisQH; }
            set { _lisQH = value;
            RaisePropertyChangedEvent("lisQH");
            }
        }

        public void cargarArchivo() {
            try {
                Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();
                dlg.FileName = documento.Trim();
                Nullable<bool> result = dlg.ShowDialog();
                if (result == true)
                {
                    documento = dlg.FileName;
                    if (File.Exists(documento))
                    {
                        StreamReader sr = File.OpenText(documento);
                        string linea = sr.ReadLine();
                        devoluciones.Clear();
                        while (linea != null)
                        {
                            devolucion dev = new devolucion();
                            dev.codref = linea.Substring(0,8);
                            dev.cantidad = Convert.ToInt32(linea.Substring(10, (linea.Length - 10)));
                            devoluciones.Add(dev);
                            linea = sr.ReadLine();
                            ERROR = true;
                        }                   

                    }
                   
                }        
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }
        
        public void guardar() {
            try {
                consNroDev();
                clases.CLSENCDEVP enc = new clases.CLSENCDEVP();
                enc.NRODEV_EDV = numero.ToString();
                enc.FECDEV_EDV = fecha;
                enc.CODCLI_EDV = selCli.CODCLI_CLI;
                enc.DOCREF_EDV = documento.Substring(documento.Length-7,7);
                enc.OBSERV_EDV = observacion;

                List<clases.CLSDETDEVP> det = new List<clases.CLSDETDEVP>();
                int i=0;
                foreach(devolucion r in devoluciones){
                    i=i+1;
                    clases.CLSDETDEVP dev =new clases.CLSDETDEVP();
                    dev.NRODEV_DDV=numero.ToString();
                    dev.CONSEC_DDV=i;
                    dev.CODREF_DDV=r.codref.Substring(0,4);
                    dev.CODCOL_DDV=r.codref.Substring(4,2);
                    dev.CODTAL_DDV=r.codref.Substring(6,2);
                    dev.CANPRO_DDV=r.cantidad;
                    dev.CODDAN1_DDV=r.codda1;
                    dev.CODDAN2_DDV=r.codda2;
                    dev.CODDAN3_DDV=r.codda3;
                    dev.CODPIE_DDV=r.codpie;
                    dev.CODRES_DDV=r.codres;
                    dev.CODCAU_DDV=r.pq;
                    dev.CODSOL_DDV=r.qh;
                    dev.CODDEC_DDV=r.decide;
                    dev.TIPO_DDV=r.tipo;
                    det.Add(dev);
                }

                if (enc.guardar(enc, det) > 0)
                {
                    msn.tipo = true;
                    msn.texto = "Devoluciones almacenadas correctamente con codigo "+enc.NRODEV_EDV;
                    consOrdProd();
                    FRMinfOrdxDev frm = new FRMinfOrdxDev();
                    frm.ShowDialog();
                }
                else {
                    msn.tipo = false;
                    msn.texto = "Las devoluciones no pueden ser almacenadas";
                }

            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }
        
       private MDOgeneral.mensaje _msn = new MDOgeneral.mensaje();
       public MDOgeneral.mensaje msn {
            get { return _msn; }
            set { _msn = value;
            RaisePropertyChangedEvent("msn");
            }
        }

       public void limpiar() {
           try {
               numero = new clases.CLSENCDEVP().QueryNroDev();
               fecha = DateTime.Today;
               codcli = "";
               documento = "";
               observacion = "";
               devoluciones.Clear();
               ERROR = true;
             
           }
           catch (Exception ex) { MessageBox.Show(ex.Message); }
       
       }

       private Boolean _ERROR=true;
       public Boolean ERROR {
           get
           {
               return _ERROR;
           }
           set {
               _ERROR = value;
               RaisePropertyChangedEvent("ERROR");
           }
       }

       private BitmapImage _imagen1 = new BitmapImage();
       public BitmapImage imagen1
       {
           get { return _imagen1; }
           set
           {
               _imagen1 = value;
               RaisePropertyChangedEvent("imagen1");
           }
       }

       public void consOrdProd() {
           try {

               OrdenesProduccion.Clear();
               clases.CLSENCDEVP encdev = new clases.CLSENCDEVP {NRODEV_EDV=numero};
               DataTable val = encdev.consOrdProxOrdDev();
               foreach (DataRow r in val.Rows) {
                   OrdenesProduccion.Add(new OrdenProduccion { 
                   strOrden=r["NROORD_DOP"].ToString(),
                   strReferencia=r["CODREF_DOP"].ToString(),
                   strNomReferencia = r["NOMREF_REF"].ToString(),
                   strNomColor =  r["NOMCOL_COL"].ToString(),
                   strColor = r["CODCOL_DOP"].ToString(),
                   strTalla= r["CODTAL_DOP"].ToString(),
                   numCantidad= Convert.ToInt32(r["CANORD_DOP"]),
                   strTipo=   r["TIPORD_EOP"].ToString()
                });
               }
           
           }
           catch (Exception ex) { MessageBox.Show(ex.Message); }
       }

       private ObservableCollection<OrdenProduccion> _OrdenesProduccion = new ObservableCollection<OrdenProduccion>();
       public ObservableCollection<OrdenProduccion> OrdenesProduccion {
           get { return _OrdenesProduccion; }
           set { _OrdenesProduccion = value;
           RaisePropertyChangedEvent("OrdenesProduccion");
           }
       } 
        
       public class OrdenProduccion:ObservableObject {

           private string _strOrden;
           public string strOrden {
               get { return _strOrden; }
               set
               {
                   _strOrden = value;
                   RaisePropertyChangedEvent("strOrden");
              }
           
           }

           private string _strReferencia;
           public string strReferencia {
               get { return _strReferencia; }
               set { _strReferencia = value;
               RaisePropertyChangedEvent("strReferencia");
               }
           }

           private string _strNomReferencia;
           public string strNomReferencia
           {
               get { return _strNomReferencia; }
               set
               {
                   _strNomReferencia = value;
                   RaisePropertyChangedEvent("strNomReferencia");
               }
           }

           private string _strColor;
           public string strColor {
               get { return _strColor; }
               set { _strColor = value;
               RaisePropertyChangedEvent("strColor");
               }
           }


           private  string _strNomColor;
           public string strNomColor
           {
               get { return _strNomColor; }
               set
               {
                   _strNomColor = value;
                   RaisePropertyChangedEvent("strNomColor");
               }
           }

           private string _strTalla;
           public string strTalla {
               get { return _strTalla; }
               set { _strTalla = value;
               RaisePropertyChangedEvent("strTalla");
               }
           }

           private int _numCantidad;
           public int numCantidad {
               get { return _numCantidad; }
               set { _numCantidad = value;
               RaisePropertyChangedEvent("numCantidad");
               }
           }

           private string _strTipo;
           public string strTipo {
               get { return _strTipo; }
               set { _strTipo = value;
               RaisePropertyChangedEvent("strTipo");
               }
           
           }

           private Boolean _logImprimir=true;
           public Boolean logImprimir {
               get { return _logImprimir; }
               set { _logImprimir = value;
               RaisePropertyChangedEvent("logImprimir");
               }
           }

       }

       public void imprimirOrdProd() {
           try {

               DataSet ds = new DataSet("dsOrdProDevolucion");
               DataTable dt = new DataTable("DTINFORDXDEV");
                            
               dt.Columns.Add("STRTIPO");
               dt.Columns.Add("STRTALLA");
               dt.Columns.Add("STRREFERENCIA");
               dt.Columns.Add("STRORDEN");
               dt.Columns.Add("STRNOMREFERENCIA");
               dt.Columns.Add("STRNOMCOLOR") ;
               dt.Columns.Add("STRCOLOR");
               dt.Columns.Add("NUMCANTIDAD");
               dt.Columns.Add("STRORDDEV");


               DataRow dr;
               foreach (OrdenProduccion r in OrdenesProduccion) {
                 
                   if (r.logImprimir)
                   {
                       dr = dt.NewRow();
                       dr["STRTIPO"] = r.strTipo;
                       dr["STRTALLA"] = r.strTalla;
                       dr["STRREFERENCIA"] = r.strReferencia;
                       dr["STRORDEN"] = r.strOrden;
                       dr["STRNOMREFERENCIA"] = r.strNomReferencia;
                       dr["STRNOMCOLOR"] = r.strNomColor;
                       dr["STRCOLOR"] = r.strColor;
                       dr["NUMCANTIDAD"] = r.numCantidad;
                       dr["STRORDDEV"] = numero;
                       dt.Rows.Add(dr);
                   }               
               }
               ds.Tables.Add(dt);
               Vista vista = new Vista { ds = ds, reporte = @"reportes\repOrdProDevolucion.rpt" };
               vista.Show();
           }
           catch (Exception ex) { MessageBox.Show(ex.Message); }
       }
 

    }



}


namespace ReglasValidacion
{

    public class esOKdevolucion : ValidationRule
    {
        public override ValidationResult Validate(object value, CultureInfo cultureInfo)
        {
            ValidationResult res;
            produccion.forms.devCli dev= produccion.forms.devCli.Instance;

            if (dev.selDev == null) {

                return new ValidationResult(true, null);
            }

            if (dev.devoluciones.Count == 0) {
                dev.ERROR = true;
            }
                       
            res = new esOKcadena { Maxc = 2000, Minc = 1 }.Validate(dev.selDev.nomref, cultureInfo);
            if (!res.IsValid)
            {
                return new ValidationResult(false, res.ErrorContent.ToString().Replace("campo", "descripcion"));
            }

            res = new esOKcadena { Maxc = 2000, Minc = 1 }.Validate(dev.selDev.codda1, cultureInfo);
            if (!res.IsValid)
            {
                return new ValidationResult(false, res.ErrorContent.ToString().Replace("campo", "daño 1"));
            }

            res = new esOKcadena { Maxc = 2000, Minc = 1 }.Validate(dev.selDev.codda2, cultureInfo);
            if (!res.IsValid)
            {
                return new ValidationResult(false, res.ErrorContent.ToString().Replace("campo", "daño 2"));
            }

            res = new esOKcadena { Maxc = 2000, Minc = 1 }.Validate(dev.selDev.codda3, cultureInfo);
            if (!res.IsValid)
            {
                return new ValidationResult(false, res.ErrorContent.ToString().Replace("campo", "daño 3"));
            }

            res = new esOKcadena { Maxc = 2000, Minc = 1 }.Validate(dev.selDev.codpie, cultureInfo);
            if (!res.IsValid)
            {
                return new ValidationResult(false, res.ErrorContent.ToString().Replace("campo", "pieza"));
            }

            res = new esOKcadena { Maxc = 2000, Minc = 1 }.Validate(dev.selDev.codres, cultureInfo);
            if (!res.IsValid)
            {
                return new ValidationResult(false, res.ErrorContent.ToString().Replace("campo", "responsable"));
            }

            res = new esOKcadena { Maxc = 2000, Minc = 1 }.Validate(dev.selDev.pq, cultureInfo);
            if (!res.IsValid)
            {
                return new ValidationResult(false, res.ErrorContent.ToString().Replace("campo", "PQ"));
            }

            res = new esOKcadena { Maxc = 2000, Minc = 1 }.Validate(dev.selDev.qh, cultureInfo);
            if (!res.IsValid)
            {
                return new ValidationResult(false, res.ErrorContent.ToString().Replace("campo", "QH"));
            }

            res = new esOKcadena { Maxc = 2000, Minc = 1 }.Validate(dev.selDev.decide, cultureInfo);
            if (!res.IsValid)
            {
                return new ValidationResult(false, res.ErrorContent.ToString().Replace("campo", "decide"));
            }

            res = new esOKentero { Maxc = 10, Minc = 1,Maxv="*",Minv="0" }.Validate(dev.selDev.cantidad, cultureInfo);
            if (!res.IsValid)
            {
                return new ValidationResult(false, res.ErrorContent.ToString().Replace("campo", "cantidad"));
            }

            return new ValidationResult(true, null);
        }
    }


}
